home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Languages / MacGofer 0.22d / MacGofer Sources / mac_dialogs.c < prev    next >
Text File  |  1994-05-05  |  18KB  |  818 lines
  1. stemVersion >= 0x0700)
  2.     {
  3. #if 1
  4.       StandardGetFile(NIL,nitems,typelist,&SFReply);
  5. #else
  6.       CustomGetFile(NIL,nitems,typelist,&SFReply,sfGetDialogID,
  7.                    where,setbutton,NIL,NIL,NIL,NIL);
  8. #endif
  9.  
  10.       ReplySpec = SFReply.sfFile;
  11.       getOK = SFReply.sfGood;
  12.     }
  13.   else
  14.     {
  15.       sfgetfile(&where,msg,NIL,nitems,typelist,setbutton,&Reply);
  16.  
  17.       SFReplyToFSSpec(Reply, &ReplySpec);
  18.       getOK = Reply.good;
  19.     }
  20.     
  21.   if(getOK)
  22.     {
  23.        *((char *)ReplySpec.name + (int) *((char *)ReplySpec.name)+1) = '\0';
  24.        filename = (char *)ReplySpec.name+1;
  25.     }
  26.  
  27.   savedir(ReplySpec.vRefNum,ReplySpec.parID,TRUE);
  28.   return(filename);
  29. }
  30.  
  31.  
  32. /*
  33.   Packaged SFGetFile dialog.
  34.   Return the string chosen or "" if cancelled.
  35.   Use the named dialog rather than the standard SF dialog.
  36. */
  37.  
  38. char *askgetfile(nitems,typelist,prompt,buttonstring,dlg6,dlg7)
  39. short nitems;
  40. SFTypeList typelist;
  41. char *prompt, *buttonstring;
  42. short dlg6, dlg7;
  43. {
  44.   Point where;
  45.   FInfo dummyFInfo;
  46.  
  47.  
  48.   SetCursor(&(qd.arrow));
  49.   SetPt(&where,75,35);
  50.   strcpy(sfbuttontext,buttonstring);
  51.  
  52.   if(systemVersion >= 0x0700)
  53.     {
  54.       StandardFileReply Reply;
  55.  
  56.       CustomGetFile(NIL,nitems,typelist,&Reply,dlg7,where,NIL,
  57.                     NIL,NIL,NIL,NIL);
  58.  
  59.       if(Reply.sfGood)
  60.         {
  61.           ReplySpec = Reply.sfFile;
  62.           ReplyExists = HGetFInfo(ReplySpec.vRefNum,ReplySpec.parID,ReplySpec.name,&dummyFInfo) == noErr;
  63.           *((char *)ReplySpec.name + (int) *((char *)ReplySpec.name)+1) = '\0';
  64.           return((char *)ReplySpec.name+1);
  65.     }
  66.       else
  67.         return("");
  68.     }
  69.   else
  70.     {
  71.       if(dlg6 == 0)
  72.         sfgetfile(&where,"",NIL,nitems,typelist,setbutton,&Reply);
  73.       else
  74.         sfpgetfile(&where,"",NIL,nitems,typelist,setSFPbutton,&Reply,dlg6,NIL);
  75.  
  76.       if(Reply.good)
  77.         {
  78.           SFReplyToFSSpec(Reply, &ReplySpec);
  79.           ReplyExists = HGetFInfo(ReplySpec.vRefNum,ReplySpec.parID,ReplySpec.name,&dummyFInfo) == noErr;
  80.  
  81.           *((char *)Reply.fName + (int) *((char *)Reply.fName)+1) = '\0';
  82.           return((char *)Reply.fName+1);
  83.         }
  84.       else
  85.         return("");
  86.     }
  87. }
  88.  
  89.  
  90. /*
  91.   Packaged SFPutFile dialog.
  92.  
  93.   Return the name of the file chosen or "" if cancelled.
  94. */
  95.  
  96. char *putfile(title,defaultfile,buttonstring)
  97. char *title, *defaultfile, *buttonstring;
  98. {
  99.   Point where;
  100.   FInfo dummyFInfo;
  101.   char *filename = "";
  102.   Boolean putOK;
  103.   StandardFileReply SFReply;
  104.  
  105.   SetCursor(&(qd.arrow));
  106.   SetPt(&where,75,35);
  107.   strcpy(sfbuttontext,buttonstring);
  108.  
  109.   
  110.   if(systemVersion >= 0x0700)
  111.     {
  112. #if 1
  113.       StandardPutFile(c2pstr(title),c2pstr(defaultfile),&SFReply);
  114. #else
  115.       CustomPutFile(c2pstr(title),c2pstr(defaultfile),&SFReply,
  116.                     sfPutDialogID,where,setbutton,NIL,NIL,NIL,NIL);
  117. #endif
  118.       (void)p2cstr(title);
  119.       (void)p2cstr(defaultfile);
  120.  
  121.       ReplySpec = SFReply.sfFile;
  122.       putOK = SFReply.sfGood;
  123.     }
  124.   else
  125.     {
  126.       sfputfile(&where,title,defaultfile,setbutton,&Reply);
  127.       SFReplyToFSSpec(Reply, &ReplySpec);
  128.       putOK = Reply.good;
  129.     }
  130.  
  131.   if(putOK)
  132.     {
  133.       *((char *)ReplySpec.name + (int) *((char *)ReplySpec.name)+1) = '\0';
  134.       filename = (char *)ReplySpec.name+1;
  135.     }
  136.  
  137.   if(*filename != '\0')
  138.     ReplyExists = HGetFInfo(ReplySpec.vRefNum,ReplySpec.parID,ReplySpec.name,&dummyFInfo) == noErr;
  139.  
  140.   savedir(ReplySpec.vRefNum,ReplySpec.parID,TRUE);
  141.   return(filename);
  142. }
  143.  
  144.  
  145.  
  146. /*
  147.    Set the text of a button.
  148.    Used as a dialog hook in an SF dialog.
  149. */
  150.  
  151. pascal short setbutton(item,dlg)
  152. short item;
  153. DialogPtr dlg;
  154. {
  155.   static Boolean dohighlight = FALSE;
  156.   if(dohighlight)
  157.     {
  158.       highlightDefault(dlg);
  159.       dohighlight = FALSE;
  160.     }
  161.   
  162.   if(*sfbuttontext != '\0')
  163.     {
  164.       SetButtonTitle(dlg,OK,sfbuttontext);
  165.       dohighlight = TRUE;
  166.       *sfbuttontext = '\0';
  167.     }
  168.   return(item);
  169. }
  170.  
  171.  
  172. /*
  173.    Set the text of a button.
  174.    Used as a dialog hook in an SFP dialog.
  175.    
  176.    We don't highlight the default, since with SFP calls, we can't highlight
  177.    until after first event.
  178.    
  179.    -- MS
  180. */
  181.  
  182. pascal short setSFPbutton(item,dlg)
  183. short item;
  184. DialogPtr dlg;
  185. {
  186.   if(*sfbuttontext != '\0')
  187.     {
  188.       SetButtonTitle(dlg,OK,sfbuttontext);
  189.       *sfbuttontext = '\0';
  190.     }
  191.   return(item);
  192. }
  193.  
  194.  
  195. /*
  196.     Set the title of a button.
  197. */
  198.  
  199. SetButtonTitle(dlg,item,text)
  200. DialogPtr dlg;
  201. short item;
  202. char *text;
  203. {
  204.   setctitle(getctlhandle(item,dlg),text);
  205. }
  206.  
  207.  
  208. /*
  209.     Disable/Enable a button.
  210. */
  211.  
  212. DisableButton(dlg,item)
  213. DialogPtr dlg;
  214. short item;
  215. {
  216.   HiliteControl(getctlhandle(item,dlg),255);
  217. }
  218.  
  219.  
  220. EnableButton(dlg,item)
  221. DialogPtr dlg;
  222. short item;
  223. {
  224.   HiliteControl(getctlhandle(item,dlg),0);
  225. }
  226.  
  227.  
  228.  
  229. /* 
  230.   Get a handle for a dialog item
  231. */
  232.  
  233. Handle gethandle(item,dialogptr)
  234. short item;
  235. DialogPtr dialogptr;
  236. {
  237.   short itemtype;
  238.   Rect itemrect;
  239.   Handle itemhandle;
  240.     
  241.   GetDItem(dialogptr,item,&itemtype,&itemhandle,&itemrect);
  242.   return(itemhandle);
  243. }
  244.  
  245.  
  246. /* 
  247.   Get the type of a dialog item
  248. */
  249.  
  250. short getitemtype(item,dialogptr)
  251. short item;
  252. DialogPtr dialogptr;
  253. {
  254.   short itemtype;
  255.   Rect itemrect;
  256.   Handle itemhandle;
  257.     
  258.   GetDItem(dialogptr,item,&itemtype,&itemhandle,&itemrect);
  259.   return(itemtype);
  260. }
  261.  
  262. GetDlgItemRect(dialogptr, item, itemrect)
  263. DialogPtr dialogptr;
  264. short item;
  265. Rect *itemrect;
  266. {
  267.   short itemtype;
  268.   Handle itemhandle;
  269.     
  270.   GetDItem(dialogptr,item,&itemtype,&itemhandle,itemrect);
  271. }
  272.  
  273.  
  274.  
  275. ControlHandle getctlhandle(item,dialogptr)
  276. short item;
  277. DialogPtr dialogptr;
  278. {
  279.   return((ControlHandle) gethandle(item,dialogptr));
  280. }
  281.  
  282.  
  283.  
  284. /* 
  285.     Highlight the Default button in a dialog
  286. */
  287.  
  288. void highlightDefault(dlgarg)
  289. DialogPtr dlgarg;
  290. {
  291.   DialogPeek dlg = (DialogPeek) dlgarg;
  292.   short button = (dlg)->aDefItem;
  293.   Rect displayRect;
  294.   short itemType;
  295.   Handle itemHandle;
  296.   WindowPtr SavePort;
  297.  
  298.   GetDItem((DialogPtr)dlg,button,&itemType,&itemHandle,&displayRect);
  299.   GetPort(&SavePort);
  300.   SetPort((WindowPtr)dlg);
  301.   PenSize(3,3);
  302.   InsetRect(&displayRect,-4,-4);
  303.   FrameRoundRect(&displayRect,16,16);
  304.   SetPort(SavePort);
  305. }
  306.  
  307.  
  308.  
  309. /*
  310.     Draw the frame around a dialog item.
  311. */
  312.  
  313. DrawFrame(dlg,item)
  314. DialogPtr dlg;
  315. short item;
  316. {
  317.   Rect displayRect;
  318.   short itemType;
  319.   Handle itemHandle;
  320.  
  321.   GetDItem(dlg,item,&itemType,&itemHandle,&displayRect);
  322.   FrameDlgRect(dlg,displayRect);
  323. }
  324.  
  325.  
  326. /*
  327.     Draw the frame around a Rect.
  328. */
  329.  
  330. FrameDlgRect(dlg,rect)
  331. DialogPtr dlg;
  332. Rect rect;
  333. {
  334.   WindowPtr SavePort;
  335.  
  336.   GetPort(&SavePort);
  337.   SetPort((WindowPtr)dlg);
  338.   PenNormal();
  339.   OffsetRect(&rect,2,2);
  340.   FrameRect(&rect);
  341.   SetPort(SavePort);
  342. }
  343.  
  344.  
  345. /*
  346.     Frame a dialog list item.
  347. */
  348.  
  349. FrameDlgList(dlg,rect)
  350. DialogPtr dlg;
  351. Rect rect;
  352. {
  353.   WindowPtr SavePort;
  354.  
  355.   GetPort(&SavePort);
  356.   SetPort((WindowPtr)dlg);
  357.   PenNormal();
  358.   OffsetRect(&rect,2,2);
  359.   SetRect(&rect,rect.left-4,rect.top-3,rect.right-1,rect.bottom-1);
  360.   FrameRect(&rect);
  361.   SetPort(SavePort);
  362. }
  363.  
  364.  
  365. /*
  366.     Set the text of an edittext or static text item.
  367. */
  368.  
  369. SetDlgItemText(dlg,item,text)
  370. DialogPtr dlg;
  371. short item;
  372. char *text;
  373. {
  374.   Handle itemhandle = gethandle(item,dlg);
  375.   setitext(itemhandle,text);
  376.  
  377.   if (getitemtype(item, dlg) == editText)     /* Only select if it's editable */
  378.      SelIText(dlg,item,0,32767);
  379. }
  380.  
  381.  
  382. /*
  383.     Set Dialog item text from an Int value.
  384. */
  385.  
  386.  
  387. SetDlgItemETVal(dlg,item,value)
  388. DialogPtr dlg;
  389. short item;
  390. int value;
  391. {
  392.   char sval[20];
  393.   sprintf(sval,"%d",value);
  394.   SetDlgItemText(dlg,item,sval);
  395. }
  396.  
  397.  
  398. /*
  399.     Get Dialog item value from its text.
  400. */
  401.  
  402. Boolean GetDlgItemETVal(dlg,item,value)
  403. DialogPtr dlg;
  404. short item;
  405. int *value;
  406. {
  407.   char sval[256];
  408.   int temp;
  409.   
  410.   getitext(gethandle(item,dlg),sval);
  411.  
  412.   if((temp = atoi(sval)) > 0)
  413.     {
  414.       *value = temp;
  415.       return(TRUE);
  416.     }
  417.  
  418.   return(FALSE);
  419. }
  420.  
  421.  
  422. /*
  423.     Set the value of a dialog control.
  424. */
  425.  
  426. SetDlgItemValue(dlg,item,value)
  427. DialogPtr dlg;
  428. short item, value;
  429. {
  430.   SetCtlValue(getctlhandle(item,dlg),value);    
  431. }
  432.  
  433.  
  434.  
  435. /*
  436.     Invert the value of a dialog control.
  437.     Used for check-boxes and radio-controls.
  438. */
  439.  
  440. InvertDlgItemValue(dlg,item)
  441. DialogPtr dlg;
  442. short item;
  443. {
  444.   ControlHandle ctlhandle = getctlhandle(item,dlg);
  445.   short itemvalue = GetCtlValue(ctlhandle);    
  446.   SetCtlValue(ctlhandle,!itemvalue);    
  447. }
  448.  
  449.  
  450. /*
  451.     Set the picture for a dialog item to PICT #pic
  452. */
  453.  
  454. SetDItemPic(dialog,item,pic)
  455. DialogPtr dialog;
  456. short item, pic;
  457. {
  458.   Handle OldPicHandle;
  459.   PicHandle NewPicHandle;
  460.   Rect box;
  461.   short itype;
  462.   
  463.   GetDItem(dialog,item,&itype,&OldPicHandle,&box);
  464.   NewPicHandle = GetPicture(pic);
  465.   if(NewPicHandle != NIL)
  466.     SetDItem(dialog,item,itype,(Handle)NewPicHandle,&box);
  467. }
  468.  
  469.  
  470. /*
  471.     Enable standard buttons.
  472. */
  473.  
  474. EnableButtons(dlg)
  475. DialogPtr dlg;
  476. {
  477.   EnableButton(dlg,((DialogPeek)dlg)->aDefItem);
  478.   if(dlgOtherButton != 0)
  479.   EnableButton(dlg,dlgOtherButton);
  480. }
  481.  
  482.  
  483. /*
  484.     Dialog FIlter Procedure for List items.
  485. */
  486.  
  487.  
  488. pascal Boolean ListDlgFilter(dlg,event,itemhit)
  489. DialogPtr dlg;
  490. EventRecord *event;
  491. short *itemhit;
  492. {
  493.   static long lastkey = 0;
  494.   KeyModifiers = event->modifiers;
  495.  
  496.   switch (event->what)
  497.     {
  498.       case keyDown:
  499.       case autoKey:
  500.         {
  501.           char  ch = (char) (event->message & charCodeMask);                         /* Convert to ASCII */
  502.       
  503.       if(ch == '\n' || ch == '\r' || ch == ENTERkey)
  504.         {
  505.           *itemhit = ((DialogPeek)dlg)->aDefItem;
  506.           return(TRUE);
  507.         }
  508.         
  509.       else if ((event->modifiers & cmdKey) != 0)
  510.         {
  511.           if(ch == '.' )
  512.             {
  513.               *itemhit = CANCEL;
  514.           return(TRUE);
  515.         }
  516.             }
  517.         
  518.       else if (ch == ESC)
  519.         {
  520.           *itemhit = CANCEL;
  521.           return(TRUE);
  522.             }
  523.  
  524.       else if (cursorkey(ch))
  525.         {
  526.           dlgarrowkey(dlgsearchlist,(Boolean)(ch==UARROWkey||ch==LARROWkey));
  527.           EnableButtons(dlg);
  528.           lastkey = 0;
  529.         }
  530.  
  531.       else
  532.         {
  533.           /* Reset the search string after a certain interval */
  534.           if (event->when - lastkey > KEY_THRESHOLD)
  535.             {
  536.               dlgsearchsize = 0;
  537.               SetPt(&dlgsearchfrom,0,0);
  538.             }
  539.         
  540.           /* extend the search string and record the time */
  541.           lastkey = event->when;
  542.           dlgsearch[dlgsearchsize++] = ch;
  543.  
  544.           /* Try to find the next matching cell */
  545.           if(findcellmatching(dlgsearch,dlgsearchsize,
  546.                               dlgsearchlist,&dlgsearchfrom,dlgcasesens))
  547.         EnableButtons(dlg);
  548.           else
  549.             dlgsearchsize--;
  550.         }
  551.     }
  552.     break;
  553.  
  554.       /* mouseDown outside any item should reset the selection */
  555.       case mouseDown:
  556.     lastkey = 0;
  557.         if(*itemhit == 0)
  558.       {
  559.             UnsetListSelection(dlgsearchlist);
  560.           return(TRUE);
  561.       }
  562.     break;
  563.     }
  564.  
  565.   return(FALSE);
  566. }
  567.  
  568.  
  569. /*
  570.     Handle arrow keys in a list dialog.
  571. */
  572.  
  573. dlgarrowkey(list,up)
  574. ListHandle list;
  575. Boolean up;
  576. {
  577.   Cell sel;
  578.   Boolean newsel;
  579.  
  580.   SetPt(&sel,0,0);
  581.   newsel = !LGetSelect(TRUE,&sel,list);
  582.  
  583.   if(up || !up && (newsel || LNextCell(TRUE,TRUE,&sel,list)))
  584.     {
  585.       UnsetListSelection(list);
  586.       if(sel.v > 0 && up)
  587.         --sel.v;
  588.     
  589.       /* Force scrolling for the last item in the list */
  590.       if(!up && !newsel)
  591.         {
  592. /*      LDoDraw(FALSE,list);*/
  593.       ++sel.v;
  594.           LSetSelect(TRUE,sel,list);
  595.           LAutoScroll(list);
  596.           LSetSelect(FALSE,sel,list);
  597.       --sel.v;
  598. /*      LDoDraw(TRUE,list);*/
  599.     }
  600.  
  601.       /* Highlight the new item and scroll to it */
  602.       LSetSelect(TRUE,sel,list);
  603.       LAutoScroll(list);
  604.     }
  605. }
  606.  
  607. /*
  608.     Reset Dialog search parameters.
  609. */
  610.  
  611. resetDlgSearch(list,casesens)
  612. ListHandle list;
  613. Boolean casesens;
  614. {
  615.   SetPt(&dlgsearchfrom,0,0);
  616.   dlgsearchsize = 0;
  617.   dlgsearchlist = list;
  618.   dlgcasesens = casesens;
  619. }
  620.  
  621.  
  622. /*
  623.      Find the first matching cell from the location given.
  624. */
  625.  
  626.  
  627. findcellmatching(match,size,list,from,casesens)
  628. char match[];
  629. short size;
  630. ListHandle list;
  631. Cell *from;
  632. Boolean casesens;
  633. {
  634.   char buff[256];
  635.   short len;
  636.   Cell  next;
  637.   SetPt(&next,from->h,from->v);
  638.  
  639.  if(list != NIL)
  640.     {
  641.       while(TRUE)
  642.         {
  643.           len = 255;
  644.           LGetCell(buff,&len,next,list);
  645.       buff[len] = '\0';
  646.           if(len >= size && equalitems(buff,match,size,casesens))
  647.         {
  648.           UnsetListSelection(list);
  649.           LSetSelect(TRUE,next,list);
  650.           HLock((Handle)list);
  651.           SetPt(&((*list)->clikLoc),next.h,next.v);
  652.           HUnlock((Handle)list);
  653.           LAutoScroll(list);
  654.           from->v = next.v;
  655.           return(TRUE);
  656.         }
  657.  
  658.       if(!LNextCell(TRUE,TRUE,&next,list))
  659.         return(FALSE);
  660.     }
  661.     }
  662. }
  663.  
  664.  
  665. int equalitems(i1,i2,len,casesens)
  666. char *i1, *i2;
  667. int len;
  668. Boolean casesens;
  669. {
  670.   int count;
  671.  
  672.   for(count=0; count < len; ++count,++i1,++i2)
  673.     if(casesens)
  674.       {
  675.         if(*i1!=*i2)
  676.           return(FALSE);
  677.       }
  678.     else if(ftolower(*i1)!=ftolower(*i2))
  679.       return(FALSE);
  680.  
  681.   return(TRUE);
  682. }
  683.  
  684.  
  685.  
  686. UnsetListSelection(list)
  687. ListHandle list;
  688. {
  689.   Cell sel;
  690.   
  691.   SetPt(&sel,0,0);
  692.   while(LGetSelect(TRUE,&sel,list))
  693.     LSetSelect(FALSE,sel,list);
  694. }
  695.  
  696.  
  697.  
  698. /*************************************************************************
  699.  
  700.   Error and debug Alerts.
  701.  
  702. *************************************************************************/
  703.  
  704.  
  705.  
  706. /*
  707.   Complain to the user about something.
  708. */
  709.  
  710. void Complain(file,theStringIndex)
  711. char *file;
  712. short theStringIndex;
  713. {
  714.    char complaint[256];
  715.    getindstring(complaint, Res_Complaint_Strings, theStringIndex);
  716.    paramtext(file,complaint,"","");
  717.    SetCursor(&qd.arrow);
  718.    (void) Alert(Res_Complaint_Alert, NIL);
  719. }
  720.  
  721.  
  722. /*
  723.     Show an error dialog.
  724. */
  725.  
  726. Error(e,s)
  727. char *e,  *s;
  728. {
  729.   SetCursor(&(qd.arrow));
  730.   paramtext(e,s,"","");
  731.   StopAlert(Res_Error_Alert,NIL);
  732. }
  733.  
  734.  
  735. /*
  736.     Show an error dialog, and abort to the main program.
  737. */
  738.  
  739. AbortError(e,s)
  740. char *e,  *s;
  741. {
  742.   extern jmp_buf catch_error;
  743.   Error(e,s);
  744.   longjmp(catch_error,1);
  745. }
  746.  
  747.  
  748. /*
  749.     Show an error dialog with an integer argument, 
  750.     and abort to the main program.
  751. */
  752.  
  753.  
  754. AbortErrorN(fmt,n)
  755. char *fmt;
  756. int n;
  757. {
  758.   char s[256];
  759.   sprintf(s,fmt,n);
  760.   AbortError("",s);
  761. }
  762.  
  763. /*
  764.     Show an error dialog, and quit MacGofer.
  765. */
  766.  
  767. FatalError(s)
  768. char *s;
  769. {
  770.   quit = TRUE;
  771.   AbortError("Fatal ",s);
  772. }
  773.  
  774.  
  775.  
  776. /*
  777.     Various dialogs used when debugging.
  778. */
  779.  
  780.  
  781.  
  782. Debug(s)
  783. char *s;
  784. {
  785.   SetCursor(&(qd.arrow));
  786.   paramtext(s,"","","");
  787.   NoteAlert(Res_Debug_Alert,NIL);
  788. }
  789.  
  790.  
  791. Debug2(fmt,a1)
  792. char *fmt, *a1;
  793. {
  794.   char str[256];
  795.  
  796.   sprintf(str,fmt,a1);
  797.   Debug(str);
  798. }
  799.  
  800. Debug3(fmt,a1,a2)
  801. char *fmt, *a1, *a2;
  802. {
  803.   char str[256];
  804.  
  805.   sprintf(str,fmt,a1,a2);
  806.   Debug(str);
  807. }
  808.  
  809. Debug4(fmt,a1,a2,a3)
  810. char *fmt, *a1, *a2, *a3;
  811. {
  812.   char str[256];
  813.  
  814.   sprintf(str,fmt,a1,a2,a3);
  815.   Debug(str);
  816. }
  817.  
  818.